const findMembers = function (instance, {
  prefix, /* 属性必须以指定prefix开头*/
  specifiedType, /* 属性必须是制定类型的实例*/
  filter /* 自定义过滤方法*/
}) {
  return _find(instance);

  // 递归函数
  function _find(instance) {
    //基线条件（跳出递归）
    if (instance.__proto__ === null) return [];

    let names = Reflect.ownKeys(instance);
    names = names.filter((name) => {
      // 过滤掉不满足条件的属性或方法名
      return _shouldKeep(name)
    });

    return [...names, ..._find(instance.__proto__)]
  }

  function _shouldKeep(value) {
    if (filter) {
      if (filter(value)) {
        return true
      }
    }
    if (prefix)
      if (value.startsWith(prefix))
        return true;
    if (specifiedType)
      if (instance[value] instanceof specifiedType)
        return true;
  }
};

/**
 * 验证数组成员是否全是某种类型的数组
 * @param type
 * @return {function(...[*]=)}
 */
function isArrayOf(type) {
  return (arr) => {
    if (!Array.isArray(arr)) return false;
    if (!type) return true;
    for (let item of arr) {
      if (typeof item !== type) return false;
    }
    return true
  }
}

/**
 * 按索引位置对字符串切一刀
 * @param str
 * @param index
 * @return {*[]}
 */
function splitByIndex(str, index) {
  return [str.slice(0, index), str.slice(index + 1)];
}

/**
 * 按separator最后出现的位置切一刀
 * @param str
 * @param separator
 * @return {*[]}
 */
function splitByLastSeparator(str, separator) {
  const index = str.lastIndexOf(separator);
  return splitByIndex(str, index);
}

module.exports = {
  findMembers
  , isArrayOf
  , splitByIndex
  , splitByLastSeparator
};
